package model.trie;

import model.registro.ConversionesTiposDatos;

//cambio el nodo hijo y hermano por los ids de los mismos
//PERO ahora habria q implementar una funcion algo asi como "iranodo(x) para q siga funcionando todo
//el problema es que deberiamos especificar el id del hijo Y el bloque donde esta, lo cual COMO LO SABEMOS
public class NodoTrie
{	
	//identificador del nodo
	private int idNodo;
	//id del hijo
	private int hijo;
	//label del nodo q puede ser un char o varios si es el ultimo nivel
	private String to_label;
	//id del hermano
	private int hermano;
	//la informacion q almacena el nodo, en este caso el offset de audio
	private Object data;
	
	//El constructor solo se utiliza una vez para crear el nodo raiz, luego todos los nodos se van
	 // agregando con el metodo add

	public NodoTrie(Object data,int l, String label)
	{
		this.hijo = -1;
		this.hermano = -1;
		this.data = data;
		this.idNodo = (int) l;
		this.to_label = label;
	}

	public NodoTrie() {}

	public int getHermano() {
		return this.hermano;
	}

	public void setHermano(int hermano) {
		this.hermano = hermano;
	}

	public int getHijo() {
		return this.hijo;
	}

	public void setHijo(int hijo) {
		this.hijo = hijo;
	}

	public int getIdNodo() {
		return this.idNodo;
	}

	public void setIdNodo(int idNodo) {
		this.idNodo = idNodo;
	}

	public String getTo_label() {
		return this.to_label;
	}

	public void setTo_label(String to_label) {
		this.to_label = to_label;
	}
	
	public Object getData ()
	{
		return this.data;
	}
	
	public void setData(Object data) {
		this.data = data;
	}

	public byte[] convertirNodoABytes() {
	//Creo arrays de bytes , uno para cada elemento a transformar 
		
		byte[] bytesIdNodo=new byte[ConversionesTiposDatos.sizeOfInt()];
		byte[] bytesNodoHijo=new byte[ConversionesTiposDatos.sizeOfInt()];
		byte[] bytesStringHijo=new byte[this.to_label.getBytes().length];
		byte[] bytesNodoHermano=new byte[ConversionesTiposDatos.sizeOfInt()];
		byte[] bytesData=new byte[ConversionesTiposDatos.sizeOfInt()];//offset es un int
	
				
		//Transformo cada elemento a bytes	
		bytesIdNodo = ConversionesTiposDatos.convertirIntABytes(this.idNodo);
		bytesNodoHijo = ConversionesTiposDatos.convertirIntABytes(this.hijo);
		bytesNodoHermano = ConversionesTiposDatos.convertirIntABytes(this.hermano);
		bytesData = ConversionesTiposDatos.convertirIntABytes((Integer)this.data);
		bytesStringHijo = this.to_label.getBytes();

		//Creo un solo array del tamanio de la suma de todos los elementos
		byte[] bytesNodoTrie = new byte[bytesIdNodo.length+bytesNodoHijo.length+bytesStringHijo.length+bytesNodoHermano.length+bytesData.length];
		//Escribo en el array los bytes de cada elemento uno consecutivo al otro		
		
		int i=0;
		int j=0;
		
		for (i=0; i<bytesIdNodo.length; i++)
			bytesNodoTrie[i]=bytesIdNodo[i];
		
		for (j=0; j<bytesNodoHijo.length; j++) {
			bytesNodoTrie[i]=bytesNodoHijo[j];
			i++;
		}
				
		for (j=0; j<bytesNodoHermano.length; j++) {
			bytesNodoTrie[i]=bytesNodoHermano[j];
			i++;
		}
		
		for (j=0; j<bytesData.length; j++) {
			bytesNodoTrie[i]=bytesData[j];
			i++;
		}
		
		for (j=0; j<bytesStringHijo.length; j++) {
			bytesNodoTrie[i]=bytesStringHijo[j];
			i++;
		}
		
		return bytesNodoTrie;
	}
	
	//Lee una tira de bytes y la transforma en un registro de Diccionario
	public void convertirBytesANodo(byte[] xBytesAConvertir) {
		
		byte[] bytesIdNodo=new byte[ConversionesTiposDatos.sizeOfInt()];
		byte[] bytesNodoHijo=new byte[ConversionesTiposDatos.sizeOfInt()];
		byte[] bytesNodoHermano=new byte[ConversionesTiposDatos.sizeOfInt()];
		byte[] bytesData=new byte[ConversionesTiposDatos.sizeOfInt()]; //offset es un int
		byte[] bytesStringHijo=new byte[xBytesAConvertir.length-(4*ConversionesTiposDatos.sizeOfInt())];
			
		int i=0;
		int j=0;
		
		for (i=0; i<ConversionesTiposDatos.sizeOfInt(); i++)
			bytesIdNodo[i]=xBytesAConvertir[i];
		
		for (j=0; j<ConversionesTiposDatos.sizeOfInt(); j++) {
			bytesNodoHijo[j]=xBytesAConvertir[i];
			i++;
		}
		
		for (j=0; j<ConversionesTiposDatos.sizeOfInt(); j++) {
			bytesNodoHermano[j]=xBytesAConvertir[i];
			i++;
		}
		
		for (j=0; j<ConversionesTiposDatos.sizeOfInt(); j++) {
			bytesData[j]=xBytesAConvertir[i];
			i++;
		}

		for (j=0; j<bytesStringHijo.length; j++) {
			bytesStringHijo[j]=xBytesAConvertir[i];
			i++;
		}

		this.idNodo=ConversionesTiposDatos.convertirBytesAInt(bytesIdNodo);
		this.hijo=ConversionesTiposDatos.convertirBytesAInt(bytesNodoHijo);
		this.hermano=ConversionesTiposDatos.convertirBytesAInt(bytesNodoHermano);
		this.data=ConversionesTiposDatos.convertirBytesAInt(bytesData);
		
		this.to_label=new String(bytesStringHijo);			
			
	}
	
	//impresion del nodo para control
	public void imprimirNodo() {
		
		System.out.println("Id: "+this.idNodo+
						   " Hijo: "+this.hijo+
						   " Hermano: "+this.hermano+
						   " OffSet: "+(Integer)this.data+
						   " Etiqueta: "+this.to_label);
		
	}

}

